package org.example.dataStructure.array;

import java.util.concurrent.ThreadLocalRandom;

/**
 * @author yuwl
 * @description 数组
 * @since 2024-07-12 14:15
 */
public class ArrayTest {

    public static void main(String[] args) {
        // 1.初始化数组
        int[] arr = new int[5]; // {0, 0, 0, 0, 0}
        int[] nums = {1, 3, 2, 5, 4};

        // 2.访问元素
        int num = randomAccess(nums);
        System.out.println("num = " + num);

        // 3.插入元素
        insert(nums, 6, 1);

        // 4.删除元素
        remove(nums, 2);

        // 5.遍历数组
        traverse(nums);

        // 6.查找元素
        int findNum = find(nums, 2);
        System.out.println("findNum = " + findNum);

        // 7.扩容数组
        int[] extend = extend(nums, 10);
        traverse(extend);
    }

    /**
     * 扩容数组
     * @param nums
     * @param enlarge
     * @return
     */
    public static int[] extend(int[] nums, int enlarge) {
        // 初始化一个扩展长度后的数组
        int[] res = new int[nums.length + enlarge];
        // 将原数组中的元素复制到新数组
        for (int i = 0; i < nums.length; i++) {
            res[i] = nums[i];
        }
        // 返回扩展后的新数组
        return res;
    }

    /**
     * 在数组中查找指定的元素，输出对应的索引
     * @param nums
     * @param target
     * @return
     */
    public static int find(int[] nums, int target) {
        for (int i = 0; i < nums.length - 1; i++) {
            if (nums[i] == target) {
                return i;
            }
        }
        return -1;
    }

    /**
     * 遍历数组元素
     * @param nums
     */
    public static void traverse(int[] nums) {
        int count = 0;
        // 通过索引遍历数组
        for (int i = 0; i < nums.length; i++) {
            count += nums[i];
        }
        // 直接遍历数组元素
        for (int num : nums) {
            System.out.println(num);
        }
    }

    /**
     * 删除索引 index 处的元素
     * @param nums
     * @param index
     */
    public static void remove(int[] nums, int index) {
        // 把索引 index 之后的元素向前移动一位
        for (int i = index; i < nums.length - 1; i++) {
            nums[i] = nums[i + 1];
        }
    }

    /**
     * 在数组的索引 index 处插入元素 num
     * @param nums
     * @param num
     * @param index
     */
    public static void insert(int[] nums, int num, int index) {
        // 把索引 index 以及之后的所有元素向后移动一位
        for (int i = nums.length - 1; i > index ; i--) {
            nums[i] = nums[i - 1];
        }
        nums[index] = num;
    }

    /**
     * 随机访问数组元素
     * @param nums
     * @return
     */
    public static int randomAccess(int[] nums) {
        int randomIndex = ThreadLocalRandom.current().nextInt(0, nums.length);
        int randomNum = nums[randomIndex];
        return randomNum;
    }
}
